Programming languages are often roughly categorized as “compiled languages” (i.e., languages that are converted from source code directly to native machine code, such as C, C++, Fortran, and Pascal), and “interpreted” languages (i.e., languages whose source code is interpreted line-by-line, such as Perl, Ruby, and Smalltalk). In reality, however, this taxonomy is an oversimplification since many traditionally interpreted languages may be compiled, and many traditionally compiled languages may also be run by special interpreters.
Furthermore, many modern languages (JAVA, Python, Lua, C#, and the like) are first compiled to an intermediate representation (e.g., “bytecode” in JAVA), which is then interpreted by a virtual machine (e.g., The JAVA Virtual Machine (JVM)) tailored to a specific operating systems and/or hardware. This is advantageous in that, generally, the use of such virtual machines facilitates the “write once, run anywhere” (WORA) model of software development. Namely, the bytecode and source code are portable, and may be used on a variety of hardware and software platforms, including various personal computers, smart-phones, personal data assistants, netbooks, and the like (generically referred to as “computers” or “computing devices.” While traditional compiled languages are generally considered to be faster than interpreted languages, to improve performance, JAVA and other similar environments often perform just-in-time (JIT) compilation (or “dynamic translation”) by converting classes and other code at runtime prior to executing it natively on the computer.
Even such cross-platform programming languages are limited, however, in that nearly all implementation choices are fixed at compile time. That is, at load time—when the software code is loaded prior to, or more or less simultaneous with, running the program—the developer cannot normally choose which variables, parameters, methods, and/or classes are to be included in the program.
Furthermore, while modern virtual machines such as the JVM are proficient in applying classical compiler optimization techniques to software code, and JIT compilers have similarly improved the performance of software to a large extent, it would nevertheless be desirable to fine tune such choices based on user interaction and/or other information about the platform or environment that is known to the system at load time.